﻿using LuckyLoot.ServiceFacade.Implementation;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using LuckyLoot.Domain.Aggregate;
using LuckyLoot.Domain.Entities;
using LuckyLoot.Domain.Entities.People;
using System.Collections.Generic;

namespace LuckyLoot.ServiceFacadeTests
{
    
    
    /// <summary>
    ///This is a test class for ApointmentServiceTest and is intended
    ///to contain all ApointmentServiceTest Unit Tests
    ///</summary>
    [TestClass()]
    public class ApointmentServiceTest
    {

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for ApointmentService Constructor
        ///</summary>
        [TestMethod()]
        public void ApointmentServiceConstructorTest()
        {
            ApointmentService target = new ApointmentService();
            Assert.Inconclusive("TODO: Implement code to verify target");
        }

        /// <summary>
        ///A test for CalculateAverageTattooPrice
        ///</summary>
        [TestMethod()]
        public void CalculateAverageTattooPriceTest()
        {
            ApointmentService target = new ApointmentService();  
            TattooApointment tattoo = null;  
            Decimal expected = new Decimal();  
            Decimal actual;
            actual = target.CalculateAverageTattooPrice(tattoo);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for ConvertVisitToTattoo
        ///</summary>
        [TestMethod()]
        public void ConvertVisitToTattooTest()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            TattooColors colors = new TattooColors();  
            TattooSize size = new TattooSize();  
            TattooStyle style = new TattooStyle();  
            TattooApointment expected = null;  
            TattooApointment actual;
            actual = target.ConvertVisitToTattoo(apointment, colors, size, style);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for ConvertVisitToTattoo
        ///</summary>
        [TestMethod()]
        public void ConvertVisitToTattooTest1()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            TattooApointment expected = null;  
            TattooApointment actual;
            actual = target.ConvertVisitToTattoo(apointment);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for DeleteAllPictures
        ///</summary>
        [TestMethod()]
        public void DeleteAllPicturesTest()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            target.DeleteAllPictures(apointment);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for DeletePicture
        ///</summary>
        [TestMethod()]
        public void DeletePictureTest()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            Picture picture = null;  
            target.DeletePicture(apointment, picture);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for DeletePicture
        ///</summary>
        [TestMethod()]
        public void DeletePictureTest1()
        {
            ApointmentService target = new ApointmentService();  
            Apointment appointment = null;  
            int photoId = 0;  
            target.DeletePicture(appointment, photoId);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for ScheduleTattoo
        ///</summary>
        [TestMethod()]
        public void ScheduleTattooTest()
        {
            ApointmentService target = new ApointmentService();  
            string title = string.Empty;  
            string description = string.Empty;  
            Customer customer = null;  
            TattooArtist artist = null;  
            DateTime date = new DateTime();  
            TattooSize size = new TattooSize();  
            TattooStyle style = new TattooStyle();  
            TattooColors colors = new TattooColors();  
            TattooApointment expected = null;  
            TattooApointment actual;
            actual = target.ScheduleTattoo(title, description, customer.Id, artist.Id, date, size, style, colors);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for ScheduleTattooSession
        ///</summary>
        [TestMethod()]
        public void ScheduleTattooSessionTest()
        {
            ApointmentService target = new ApointmentService();  
            TattooApointment tattoo = null;  
            DateTime date = new DateTime();  
            TattooApointment expected = null;  
            TattooApointment actual;
            actual = target.ScheduleTattooSession(tattoo, date);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for ScheduleVisit
        ///</summary>
        [TestMethod()]
        public void ScheduleVisitTest()
        {
            ApointmentService target = new ApointmentService();  
            string title = string.Empty;  
            string description = string.Empty;  
            Customer customer = null;  
            TattooArtist artist = null;  
            DateTime date = new DateTime();  
            Nullable<DateTime> returnDate = new Nullable<DateTime>();  
            Apointment expected = null;  
            Apointment actual;
            actual = target.ScheduleVisit(title, description, customer.Id, artist.Id, date, returnDate);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        /// <summary>
        ///A test for UpdateApointment
        ///</summary>
        [TestMethod()]
        public void UpdateApointmentTest()
        {
            /*ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            Apointment expected = null;  
            Apointment actual;
            actual = target.UpdateApointment(apointment);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");*/
        }

        /// <summary>
        ///A test for UpdateTattooApointment
        ///</summary>
        [TestMethod()]
        public void UpdateTattooApointmentTest()
        {/*
            ApointmentService target = new ApointmentService();  
            TattooApointment apointment = null;  
            TattooApointment expected = null;  
            TattooApointment actual;
            actual = target.UpdateTattooApointment(apointment);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");*/
        }

        /// <summary>
        ///A test for UploadPicture
        ///</summary>
        [TestMethod()]
        public void UploadPictureTest()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            byte[] picture = null;  
            target.UploadPicture(apointment, picture);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        /// <summary>
        ///A test for UploadPictures
        ///</summary>
        [TestMethod()]
        public void UploadPicturesTest()
        {
            ApointmentService target = new ApointmentService();  
            Apointment apointment = null;  
            List<byte[]> pictures = null;  
            target.UploadPictures(apointment, pictures);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
    }
}
